package com.neuedu.tools;

import java.text.MessageFormat;

public class StringTestDriver {
    public static void main(String[] args) {
        test03();
    }

    /**
     * String工具类：MessageFormat
     */
    private static void test03(){
        // 创建MessageFormat类的一个实例对象
        // 带占位符的格式
        String strFormat = "我是{0},来自{1},稀罕{2}";
        MessageFormat mf = new MessageFormat(strFormat);
        // 占位符需要替换的参数数组（以数组的形式或变长参数的形式提供可以替换的参数）
        Object[] paras = new Object[]{"小明","河北","写代码"};
        String strMessage = mf.format(paras);
        System.out.println(strMessage);
    }
    /**
     * String工具类：StringBuilder
     */
    private static void test02(){
        // 创建一个StringBuilder的实例对象
        StringBuilder sb = new StringBuilder();
        // 动态拼接字符串
        sb.append("Hello!");
        sb.append("小明").append(",吃饭了么？");
        System.out.println("字符串内容："+sb);
        StringBuilder sb2 = sb.reverse();
        System.out.println("Old字符串内容："+sb);
        System.out.println("Reversed字符串内容："+sb2);
        System.out.println("---------------------------------------");

        // String replace方法

        // String是按值传参的
        // 验证程序
        String stuName = "夏明";
        System.out.println("主方法中实参传递之前的值："+stuName);
        // 将实参的值通过方法调用的形式传递给形参
        test02sub(stuName); // 此处所传递的参数 stuName是实参
        System.out.println("主方法中实参传递之后的值："+stuName);
        /*
        相关概念：
            实参：函数调用时所传递的参数是实参；
            形参：函数定义时写在()中的参数；

            按值传参：实参的值传递给形参，形参进行了改变不会影响实参的值；
                8种基本数据类型（及其包装类）、String类型；
            按引用（址）传参：实参的地址引用传给形参，形参进行了改变会影响实参的值；
                除了String之外的所有的对象类型，包括数组；
         */
    }


    /**
     * 子方法调用
     * @param stuName 形参 （此处函数定义时写的参数stuName是形参）
     */
    private static void test02sub(String stuName){
        System.out.println("子方法中参数修改之前的值："+stuName);
        // 子方法对函数调用传递的值进行修改
        stuName += "lalala";
        System.out.println("子方法中参数修改之后的值："+stuName);
    }


    /**
     * 字符串存储模型，补充内容
     */
    private static void test01(){
        int i = 10; // 10 就是常量
        // 定义一个字符串
        String str00 = "小明"; // 此处 创建了 1个
        String str01 = "小明"; // 创建了 1个对象（常量池中的元素不重复）
        // 如果只有下面一行代码执行的话，请问在该行代码之后在内存中创建了 2个对象
        String str10 = new String("小明"); // 创建了 2个对象
        String str11 = new String("小明"); // 创建了 3个对象

        String str20 = "小";
        String str21 = "明";

        String str30 = str20+str21; // 堆中

        String str40 = "小"+"明"; // 栈中  // 单独此行代码，在内存中创建了个对象

        String str50 = str20+"明"; // 堆中

        System.out.println("str30 == str00::"+(str30 == str00));

        System.out.println("str40 == str00::"+(str40 == str00));

        System.out.println("str50 == str00::"+(str50 == str00));

//        System.out.println("str00 == str11::"+(str00 == str11));
    }
}